home
***
CD-ROM
|
disk
|
FTP
|
other
***
search
/
Acorn RISC PD-CD 1
/
Acorn RISC PD-CD 1.iso
/
languages
/
hope
/
hopearchie
< prev
next >
Wrap
Text File
|
1990-04-25
|
18KB
|
529 lines
U S I N G I C - H O P E O N T H E A R C H I M E D E S
1. Introduction and disclaimer
The Imperial College HOPE interpreter (IC-HOPE) is an experimental tool
originating in the Functional Programming Group of the Department of
Computing. Neither the implementation nor the documentation are complete
yet. The interpreter should be regarded only as an introduction to
functional programming and the HOPE language, not as a basis for
developing large items of software.
This document describes how to use the IC-HOPE interpreter on the Acorn
Archimedes, under RISC OS. It does not document the IC-HOPE language and
should be read in conjunction with the "Hope Tutorial" in the August 1985
edition of BYTE Magazine, a copy of which is on the distribution disk,
entitled 'HopeTutorl'.
2. Running the interpreter
After invoking the interpreter, the current directory will be displayed at
the top of the screen. Beneath this, a banner with the version number of
the interpreter will be printed, followed by the prompt ">:".
************** IC-HOPE version 4.02A (c) ICST 1989 **************
** **
** Welcome to the functional programming language HOPE **
** **
************* Warning - incomplete implementation! **************
>:
You can now start entering programs as described below.
3. Character set
The interpreter recognises the following character set:
letters: _ A B C D E F G H I J K L M N O P Q R S T U V W X Y Z
a b c d e f g h i j k l m n o p q r s t u v w x y z
digits: 0 1 2 3 4 5 6 7 8 9
operators: ` | \ ~ @ # $ % ^ & * - + = : . ? /
punctuation: ! ( ) { } [ ] ; , " '
layout: space tab newline
Using IC-Hope on the Archimedes Page 1
4. Lexical conventions
An IC-HOPE program is a sequence of words. A word is a sequence of
digits, one character in single quotes, a sequence of characters in double
quotes, a single punctuation character, an identifier or a comment.
Single-quote within single quotes and double quote within double quotes
are self-escaped and must be doubled. An identifier is a sequence of
letters and digits starting with a letter or a sequence of operator
characters; only the first 240 characters are significant.
Adjacent words formed from the same class of non-punctuation characters
must be separated by a layout character. Layout characters are
significant within double quotes except that newline is treated as a
space. A comment is a sequence of characters starting with an exclamation
mark and ending with a newline or another exclamation mark. Comments are
treated as layout characters and ignored. The following words have
predefined meanings to the interpreter and should not be used as
identifiers:
< <> <= + ++ | & * - --- -> /= _ > >= : :: :::
# = =< => == alpha and beta bisect char close data dec
display div echo else empty end eof exit false getchar
in infix intersect isin lambda let list load minus mod
modify nil nl nonop not notrace num openin openout or
print putchar putlist save set size show split stream
subset succ system then time trace true truval type
typevar union void where width with X
5. Program order
Infix declarations must appear before the operations are used in data
definitions, recursion equations or expressions. Type variables must be
declared before they are used in data definitions. Function declarations
must appear before any of their recursion equations and before they are
used in expressions. Mutually recursive data types can be declared using
the "with" connective. Provided these constraints are observed, the
elements of the program can be entered in any order.
The interpreter does not check that the patterns on the left-hand sides of
recursion equations are unique. At run-time they are checked in the order
they were entered and the first equation with a matching pattern is
evaluated. Programs should not be written to take advantage of this.
Using IC-Hope on the Archimedes Page 2
6. Standard facilities
The following declarations may be assumed to be made when the interpreter
is loaded and the types, type variables, functions and operations which
they introduce may be used without further formality.
typevar alpha, beta ;
type stream == num ;
infix isin : 3 ;
infix <>, ::, :::, or, union : 4 ;
infix +, -, and, intersect, minus, subset : 5 ;
infix =, <, >, /=, =<, >=, *, div, mod : 6 ;
data num == 0 ++ succ ( num ) ;
data truval == true ++ false ;
data char == 'A' ++ 'B' ++ 'C' ++ ... ;
data set ( alpha ) == empty ;
data list ( alpha ) == nil ++ alpha :: list ( alpha ) ++
alpha ::: list ( alpha ) ;
dec +, -, *, div, mod : ( num # num ) -> num ;
dec =, <, =<, >, >=, /= : ( alpha # alpha) -> truval ;
dec and, or : ( truval # truval ) -> truval ;
dec not : truval -> truval ;
dec <> : ( list ( alpha ) # list ( alpha ) ) ->
list ( alpha ) ;
dec close : stream -> void ;
dec eof : char ;
dec getchar : stream -> char ;
dec nl : char ;
dec show : alpha -> alpha ;
dec openin : list ( char ) -> stream ;
dec openout : list ( char ) -> stream ;
dec print : list ( char ) -> void ;
dec putchar : ( stream # char ) -> void ;
dec putlist : ( list ( list ( char ) ) # stream ) -> void ;
dec bisect : set ( alpha ) -> ( set ( alpha ) # set ( alpha ) ) ;
dec intersect : ( set ( alpha ) # set ( alpha ) ) -> set ( alpha ) ;
dec isin : ( alpha # set ( alpha ) ) -> truval ;
dec minus : ( set ( alpha ) # set ( alpha ) ) -> set ( alpha ) ;
dec size : set ( alpha ) -> num;
dec split : set ( alpha ) -> ( alpha # set ( alpha ) ) ;
dec subset : ( set ( alpha ) # set ( alpha ) ) -> truval ;
dec union : ( set ( alpha ) # set ( alpha ) ) -> set ( alpha ) ;
Using IC-Hope on the Archimedes Page 3
The full set of constructors for data type "char" is the set of ASCII
characters defined in section 3 above. The relational operators <=, , =<,
>, >= and /= have their usual meanings for "num" and "char" parameters,
with ASCII ordering for characters. They are not defined for other types,
except for =, which is also defined over structured types. Functions and
types which are not mentioned in the "Hope tutorial" are described in
section 9 below.
7. Binding conventions
The comma binds most weakly, followed by conditionals, the "let"
qualifier, the "where" qualifier, all infix operators in numeric priority
order (highest first), function application (represented by juxtaposition)
and list and set construction using quotes, brackets and braces.
In patterns, "&" binds more tightly than comma or any infix data
constructor. When a program is displayed or saved on disk (see section
10), all priorities will be shown explicitly by extra parentheses.
8. Error messages
There are three kinds of error messages. Syntax errors are detected as the
program is entered. A carot (^) character is printed beneath the word in
error. When a syntax error has been found, the interpreter skips all
words up to the next semicolon. If there are no syntax errors, the
expression is type-checked. If a type error is found the incorrect
subexpression, its actual type, and the type expected by the interpreter
are displayed. Statements or expressions with syntax or type errors are
not stored by the interpreter and must be reentered. Run-time errors
cause the interpreter to abandon the current evaluation and return to the
top level. The program is retained and may be corrected.
9. Additional features
The interpreter supports a number of language features which are not
described in the "Hope Tutorial". These are as follows:
(a) Synonyms may be declared for user-defined or built-in data types, e.g.
type word == list ( char ) ;
Objects of type "word" will be treated as "list ( char )" for
type-checking and when printing the type of results.
(b) Synonyms may also be declared for objects matched in patterns using
the "&" connective. The synonym name must precede the "&". This is used
to avoid repeating complex expressions on the right-hand-sides of
recursion equations e.g.
--- f ( l & ( h :: t ) ) <= if h = 10 then g ( t ) else g ( l ) ;
Using IC-Hope on the Archimedes Page 4
(c) Mutually recursive types may be declared using "with", e.g.
data LispList == NIL ++ CONS ( LispItem # LispList )
with LispItem == ATOM ( num ) ++ LIST ( LispList ) ;
(d) A restricted form of lazy evaluation is provided by the 'lazy cons'
list constructor ":::". This does not evaluate its second argument unless
its value is required (this includes pattern-matching). E.g.
>: 1 ::: [ 2 div 0 ] ;
>: 1 ::: [ ( 2 div 0 ) ] : list ( num )
This allows infinite lists to be constructed and manipulated. There are
no other lazy operations and other types of data may only be constructed
eagerly.
(e) The data type "set ( alpha )" is supported. Sets are denoted by
sequences of expressions within braces; duplicated values will only appear
once:
>: { 1, 1+1, 2-1, 3, 3-1 } ;
>: { 1 , 3 , 2 } : set ( num )
The empty set is denoted by empty braces or by using the constructor
"empty". No other set constructors are provided, and functions should not
pattern-match on nonempty sets. The following built-in functions (types
and fixities in section 6 above) are provided over sets:
minus set difference
intersect set intersection
union set union
isin is specified item in set?
subset is first set a subset of second?
bisect split set into two equal-sized subsets and return both
split remove arbitrary item from nonempty set and return both
size number of elements in a set
(f) The following functions (types given in section 6 above) allow more
control over input-output. Most have side-effects on files and are not
referentially transparent:
show identity function printing its argument on the terminal
print print a list of characters on the terminal
nl end-of-line character sequence
openin open an external file by name and return an input stream
openout open an external file by name and return an output stream
getchar read a character and advance the input stream
putchar write a character and advance the output stream
putlist write a list of lists of characters to an output stream
close close the file associated with a stream
eof end-of-file character sequence; returned as last character
of an input file, closes an output file when written.
Using IC-Hope on the Archimedes Page 5
10. System commands
The interpreter provides a set of commands to assist with program entry,
debugging and modification. All commands start with the command name,
followed by zero or more parameters separated by spaces and end with a
semicolon.
display causes the interpreter to list the program.
The text is reconstructed from the stored internal form and may differ
from what was originally entered in layout and in the bracketing of
expressions. It is displayed in the order: operator declarations; type
variable declarations; data definitions; function definitions with the
equations grouped together after the declaration.
The priorities of all operations are shown explicitly by the insertion of
extra parentheses. Comments are not stored and are not displayed. The
listing can be made more selective by following "display" with one of the
parameters "typevar", "operator", "data" or "function", or by the name of
a single function.
save causes the interpreter to save the complete program in
source form on an external file.
The filename is given as the parameter of the "save" command, enclosed in
double quotes, and should be 240 characters long or less. The format of
the saved source is the same as for "display" except that all function
declarations are saved before any recursion equations. This ensures that
all functions will be declared before they are used when the file is
reloaded.
load causes the interpreter to read in a program contained
in an external file.
The filename is given as the parameter of the "load" command and follows
the conventions given above for "save". The source file can be produced
by an earlier "save" command, or by a text editor, allowing top-level
applications to be included. They will be executed immediately as the
file is loaded. If a source file produced by a text editor is loaded and
resaved, it will be reformatted and any comments will be lost.
modify allows the stored internal form of a single function
to be edited.
The name of the function is given as the parameter of the command. There
is no way to alter typevar, data or infix priority declarations except by
editing a saved version of the program and reloading it.
Using IC-Hope on the Archimedes Page 6
The "modify" command is interactive and all replies may be abbreviated to
a single letter, shown by brackets in the message. The interpreter first
displays the function declaration and asks if you want to change it; reply
"(y)es" if you do. Other replies are taken as "(n)ext" and the recursion
equations are displayed. You will be prompted for the type part of the
declaration. Terminate the type with a semicolon in the usual way. When
you change a declaration the whole program is re-typechecked when the
"modify" command is complete, and type errors may appear for other
functions.
The recursion equations are then displayed one at a time. For each
equation you have the option of deleting or replacing it, or adding a new
equation before or after it. Reply "(d)elete", "(r)eplace", "(b)efore",
or "(a)fter" respectively. Other replies are taken as "(n)ext" and the
following equation is displayed. For "delete" you will be asked to
confirm your intention; reply "(y)es" to confirm the deletion. In other
cases you will be prompted for a new equation without the "---".
Terminate the equation with a semicolon.
If the new declaration or recursion equation which you enter has syntax
errors you will be asked whether you want to enter it again. Reply
"(a)gain" to try again. Other replies are taken as "(n)ext" and the old
version is kept.
echo controls the listing of loaded programs.
The parameter "off" suppresses the listing of programs entered by "load"
commands, speeding up loading. Any lines containing errors will still be
displayed. Listings can be restored by the parameter "on". The state of
the switch is displayed if the parameter is omitted.
trace causes the interpreter to display information about
the evaluation of selected functions.
The names of the functions to be traced are given as parameters or "all"
can be specified to trace all functions in the program. Tracing of the
selected functions is started by entering "trace on" and stopped by
entering "trace off". If the parameter is omitted, the interpreter will
display the currently selected functions and the state of the trace
switch.
notrace suppresses the tracing of specified functions.
The names of the functions which are not to be traced are given as
parameters or "all" can be specified to suppress the tracing of all
functions in the program.
time controls the timing of programs.
The parameter "on" causes the interpreter to give the evaluation time of
top-level expressions. Use "off" to turn off timing and omit the
parameter to show the state of the timing switch. Execution times are
given in milliseconds.
Using IC-Hope on the Archimedes Page 7
exit gets out of the interpreter.
You can also get out of the interpreter if it is expecting terminal input
by entering control-D as the FIRST character of the input line, to signal
end-of-file. Runaway recursion in user-defined functions cannot be
stopped except by pressing <reset> or <control><break>.
system enters an Archimedes operating system command.
The command must be enclosed in double quotes, and care should be taken
not to overwrite any of the Hope system's workspace. It is intended for
such things as viewing directories, changing the current directory and so
on. Running any disk-based utilities is likely to cause the system to
crash. Commands need not be prefixed with an asterisk, and are restricted
to 240 characters. If double quotes need to be included in the command a
pair of double quotes should be used for each double quote in the
command string.
width controls the line width for terminal output.
The parameter sets the point at which Hope will split lines of output. If
no parameter is given, the current width value is returned. The parameter
"off" (set by default) disables the width control and uses the entire
screen width - only wrapping round at the edge of the screen.
Using IC-Hope on the Archimedes Page 8
